package com.pai4j.zwiki.service.agent;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 增强版提示词引擎
 * 
 * 提供高质量、结构化的提示词模板，引导LLM进行深度代码分析
 * 
 * 核心理念：
 * 1. 结构化思考：引导LLM按照特定维度系统性思考
 * 2. 深度挖掘：通过追问和反思促进更深层次的理解
 * 3. 多视角分析：从不同角度审视代码（功能、架构、性能、安全等）
 * 4. 渐进式理解：从整体到细节，从表层到深层
 * 5. 知识关联：将新知识与已有知识建立联系
 *
 * @author pai4j
 * @since 2025-10-12
 */
@Slf4j
@Component
public class EnhancedPromptEngine {

    /**
     * 生成项目整体理解提示词
     * 引导LLM从宏观层面理解项目
     */
    public String buildProjectOverviewPrompt(String projectName, String readme, Map<String, Object> projectStats) {
        return String.format("""
                # 项目深度理解任务
                
                你是一位资深的软件架构师和代码审查专家。现在需要你深入理解以下项目：
                
                ## 项目基本信息
                **项目名称**: %s
                
                **项目统计**:
                %s
                
                ## README文档
                ```markdown
                %s
                ```
                
                ---
                
                请进行**系统性的深度分析**，回答以下问题：
                
                ### 第一部分：项目定位与价值 (25%%)
                1. **项目本质**: 用一句话概括这个项目的核心价值主张
                2. **问题域**: 这个项目解决了什么实际问题？为什么需要解决这个问题？
                3. **目标用户**: 谁会使用这个项目？使用场景是什么？
                4. **差异化**: 相比同类项目，这个项目的独特价值是什么？
                
                ### 第二部分：技术架构分析 (30%%)
                5. **架构模式**: 采用什么架构风格？（单体/微服务/事件驱动等）为什么这样设计？
                6. **技术栈**: 使用了哪些核心技术？每个技术的选型理由是什么？
                7. **分层设计**: 如何进行分层？各层职责是什么？层与层如何交互？
                8. **关键设计决策**: 有哪些重要的架构决策？背后的考量是什么？
                
                ### 第三部分：实现特点 (25%%)
                9. **技术亮点**: 代码实现中有哪些值得学习的技术亮点？
                10. **设计模式应用**: 使用了哪些设计模式？在什么场景下使用？
                11. **工程实践**: 遵循了哪些工程最佳实践？（如SOLID原则、DRY等）
                12. **创新之处**: 有哪些创新性的实现或独特的解决方案？
                
                ### 第四部分：质量评估 (20%%)
                13. **代码质量**: 整体代码质量如何？有哪些优点？
                14. **可维护性**: 代码的可维护性如何？易于理解和修改吗？
                15. **扩展性**: 是否便于功能扩展？架构是否具有良好的开放性？
                16. **潜在问题**: 发现了哪些潜在的技术债务或需要改进的地方？
                
                ---
                
                **要求**:
                - 每个问题都要**详细回答**，不要泛泛而谈
                - 结合**具体的技术细节**和代码特征进行分析
                - 提供**客观、专业**的技术评价
                - 总字数：**2000-2500字**
                - 使用清晰的**结构化格式**，便于阅读
                
                请开始你的深度分析：
                """,
                projectName,
                formatProjectStats(projectStats),
                readme != null && readme.length() > 30000 ? truncate(readme, 30000) : (readme != null ? readme : "无README文档")
        );
    }

    /**
     * 生成代码文件深度阅读提示词
     * 引导LLM深入理解单个代码文件
     */
    public String buildDeepCodeReadingPrompt(String filePath, String fileName, String code, String fileType) {
        return String.format("""
                # 代码深度阅读与分析
                
                作为资深代码审查专家，请**逐行仔细阅读**以下代码文件，进行深度分析：
                
                **文件路径**: `%s`
                **文件名称**: `%s`
                **文件类型**: %s
                
                ## 源代码
                ```java
                %s
                ```
                
                ---
                
                请按照以下维度进行**全面深入**的分析：
                
                ## 一、快速概览 (10%%)
                1. **一句话描述**: 这个类/文件的核心职责是什么？
                2. **在系统中的角色**: 它在整个系统架构中扮演什么角色？
                
                ## 二、结构分析 (15%%)
                3. **类结构**:
                   - 类的访问修饰符和注解说明了什么？
                   - 实现了哪些接口？继承了哪些类？为什么？
                   - 包含哪些字段？字段设计体现了什么思想？
                
                4. **依赖关系**:
                   - 依赖了哪些外部类/服务？这些依赖合理吗？
                   - 采用什么方式注入依赖？（构造器注入/字段注入/setter注入）
                   - 依赖的层次结构是否清晰？有没有循环依赖？
                
                ## 三、核心逻辑分析 (30%%)
                5. **关键方法深度剖析**:
                   对于每个重要方法，回答：
                   - 方法的输入、输出和副作用是什么？
                   - 核心算法/业务逻辑是什么？
                   - 为什么要这样实现？有什么考虑？
                   - 有哪些边界条件和异常处理？
                   - 性能考虑是什么？时间/空间复杂度如何？
                
                6. **数据流追踪**:
                   - 数据如何流入这个类？
                   - 数据在类内部如何被处理和转换？
                   - 数据如何流出这个类？
                
                7. **业务逻辑理解**:
                   - 实现了什么业务功能？
                   - 业务规则是什么？
                   - 有哪些业务约束和验证？
                
                ## 四、设计评价 (20%%)
                8. **设计模式与原则**:
                   - 使用了哪些设计模式？为什么在这里使用？
                   - 是否遵循SOLID原则？具体体现在哪里？
                   - 是否符合"高内聚、低耦合"原则？
                
                9. **代码质量**:
                   - 命名是否清晰、符合规范？
                   - 方法是否职责单一、长度适中？
                   - 注释是否充分、准确？
                   - 是否有冗余代码或重复逻辑？
                
                ## 五、技术实现细节 (15%%)
                10. **技术选型与应用**:
                    - 使用了哪些框架/库的特性？
                    - 技术使用是否恰当、符合最佳实践？
                    - 有没有值得学习的技术技巧？
                
                11. **异常处理与健壮性**:
                    - 异常处理是否完善？
                    - 是否考虑了各种边界情况？
                    - 代码的容错性如何？
                
                ## 六、改进建议 (10%%)
                12. **优化空间**:
                    - 有哪些可以改进的地方？
                    - 性能优化的可能性？
                    - 可读性和维护性的提升空间？
                    - 潜在的bug或安全隐患？
                
                ---
                
                **分析要求**:
                - 必须**通读全部代码**后再开始分析，不要遗漏重要细节
                - 对**每个公共方法**都要进行分析
                - 引用**具体的代码行**来支撑你的观点
                - 既要看到**优点**，也要指出**不足**
                - 提供**可操作的建议**，而不是泛泛而谈
                - 总字数：**1500-2000字**
                
                请开始你的深度代码分析：
                """,
                filePath,
                fileName,
                fileType,
                code // 传递完整代码，不截断！
        );
    }

    /**
     * 生成配置文件深度理解提示词
     */
    public String buildConfigurationAnalysisPrompt(String configPath, String configContent, String configType) {
        return String.format("""
                # 配置文件深度分析
                
                作为系统架构专家，请深入分析以下配置文件，理解系统的运行环境和技术架构：
                
                **配置文件**: `%s`
                **配置类型**: %s
                
                ## 配置内容
                ```
                %s
                ```
                
                ---
                
                请进行**系统性的分析**：
                
                ## 一、配置概览 (15%%)
                1. **配置目的**: 这个配置文件的主要目的是什么？
                2. **配置范围**: 配置了系统的哪些方面？
                
                ## 二、技术栈识别 (25%%)
                3. **中间件识别**:
                   - 使用了哪些数据库？配置说明了什么？
                   - 使用了哪些缓存系统？配置参数的含义？
                   - 使用了哪些消息队列？配置体现的架构特点？
                   - 还有其他哪些中间件和服务？
                
                4. **框架配置**:
                   - 框架的版本和模块配置说明了什么？
                   - 关键特性的启用/禁用反映了什么设计决策？
                
                ## 三、架构推断 (25%%)
                5. **系统架构**:
                   - 从配置推断，这是什么类型的架构？（单体/微服务/分布式）
                   - 系统的分层结构是怎样的？
                   - 有哪些外部依赖和集成点？
                
                6. **服务发现与治理**:
                   - 如何进行服务注册和发现？
                   - 配置了哪些服务治理策略？
                
                ## 四、运行环境 (20%%)
                7. **环境配置**:
                   - 这个配置适用于什么环境？（开发/测试/生产）
                   - 环境相关的配置有哪些？
                
                8. **资源配置**:
                   - 配置了哪些资源限制？（连接池、线程池等）
                   - 资源配置是否合理？
                
                ## 五、安全与性能 (15%%)
                9. **安全配置**:
                   - 有哪些安全相关的配置？
                   - 是否存在安全隐患？（如明文密码）
                
                10. **性能调优**:
                    - 哪些配置影响性能？
                    - 配置参数是否需要优化？
                
                ---
                
                **分析要求**:
                - 对**每个关键配置项**进行解释
                - 说明配置项的**作用和影响**
                - 评估配置的**合理性**
                - 指出**潜在问题**和**优化建议**
                - 总字数：**800-1200字**
                
                请开始分析：
                """,
                configPath,
                configType,
                configContent.length() > 20000 ? truncate(configContent, 20000) : configContent
        );
    }

    /**
     * 生成架构分析提示词
     */
    public String buildArchitectureAnalysisPrompt(Map<String, Object> projectStructure, String dependencies) {
        return String.format("""
                # 软件架构深度分析
                
                作为资深架构师，请基于项目结构和依赖关系，进行全面的架构分析：
                
                ## 项目结构
                %s
                
                ## 依赖关系
                %s
                
                ---
                
                请进行**多层次的架构分析**：
                
                ## 一、架构风格识别 (20%%)
                1. **整体架构风格**:
                   - 这是什么类型的架构？（分层/六边形/微服务/事件驱动等）
                   - 为什么判断是这种架构？有哪些典型特征？
                
                2. **架构演化**:
                   - 从结构能看出架构是如何演化的吗？
                   - 有没有架构重构的痕迹？
                
                ## 二、分层与模块化分析 (25%%)
                3. **分层设计**:
                   - 系统如何分层？每层的职责是什么？
                   - 层与层之间的依赖关系如何？是否有违反分层原则的地方？
                
                4. **模块划分**:
                   - 如何进行模块划分？划分依据是什么？
                   - 模块之间的耦合度如何？
                   - 模块的内聚性如何？
                
                5. **边界清晰度**:
                   - 各模块/层的边界是否清晰？
                   - 有没有职责混淆的情况？
                
                ## 三、核心组件分析 (20%%)
                6. **关键组件识别**:
                   - 哪些是核心组件？它们的作用是什么？
                   - 这些组件如何协作？
                
                7. **组件设计评价**:
                   - 组件的设计是否合理？
                   - 是否符合单一职责原则？
                
                ## 四、依赖关系分析 (20%%)
                8. **依赖方向**:
                   - 依赖的方向是否合理？
                   - 有没有循环依赖？
                   - 是否遵循依赖倒置原则？
                
                9. **关键依赖点**:
                   - 哪些类/组件被大量依赖？
                   - 这些关键节点的设计是否稳定？
                
                ## 五、架构质量评估 (15%%)
                10. **可扩展性**: 架构是否便于功能扩展？
                11. **可维护性**: 架构是否便于维护和修改？
                12. **性能考虑**: 架构设计中有哪些性能考量？
                13. **技术债务**: 存在哪些架构层面的技术债务？
                
                ---
                
                **分析要求**:
                - 基于**实际的项目结构**进行分析，不要臆测
                - 提供**架构图的文字描述**
                - 指出**架构的优点和不足**
                - 提供**改进建议**
                - 总字数：**1500-2000字**
                
                请开始架构分析：
                """,
                formatMap(projectStructure),
                dependencies.length() > 10000 ? truncate(dependencies, 10000) : dependencies
        );
    }

    /**
     * 生成业务流程分析提示词
     */
    public String buildBusinessFlowAnalysisPrompt(String entryPoint, String relatedCode, String context) {
        return String.format("""
                # 业务流程深度分析
                
                请深入分析以下业务流程，理解业务逻辑的实现：
                
                **业务入口**: %s
                
                **上下文信息**:
                %s
                
                ## 相关代码
                ```java
                %s
                ```
                
                ---
                
                请进行**端到端的业务流程分析**：
                
                ## 一、流程概览 (15%%)
                1. **业务功能**: 这个流程实现什么业务功能？
                2. **触发条件**: 什么情况下会触发这个流程？
                3. **预期结果**: 流程执行后会产生什么结果？
                
                ## 二、流程步骤拆解 (35%%)
                4. **详细步骤**: 请**逐步列出**业务流程的每个步骤：
                   - 步骤1: [描述] - 涉及的类/方法
                   - 步骤2: [描述] - 涉及的类/方法
                   - ...
                
                5. **关键节点**: 
                   - 哪些是关键的决策点？
                   - 哪些是重要的数据转换点？
                
                6. **分支与异常**:
                   - 有哪些分支逻辑？触发条件是什么？
                   - 如何处理异常情况？
                
                ## 三、数据流分析 (20%%)
                7. **输入数据**: 流程的输入是什么？数据来源？
                8. **数据转换**: 数据在流程中如何被处理和转换？
                9. **输出数据**: 流程的输出是什么？数据去向？
                
                ## 四、业务规则 (15%%)
                10. **业务约束**: 有哪些业务规则和约束？
                11. **验证逻辑**: 如何验证数据的合法性？
                12. **权限控制**: 是否有权限检查？如何实现？
                
                ## 五、质量评估 (15%%)
                13. **流程合理性**: 业务流程的设计是否合理？
                14. **错误处理**: 异常处理是否完善？
                15. **优化建议**: 流程实现有哪些可以优化的地方？
                
                ---
                
                **要求**:
                - 绘制**文字版流程图**（使用箭头和步骤描述）
                - 说明**每个步骤的职责**
                - 指出**关键的技术实现点**
                - 总字数：**1000-1500字**
                
                请开始分析：
                """,
                entryPoint,
                context.length() > 5000 ? truncate(context, 5000) : context,
                relatedCode.length() > 30000 ? truncate(relatedCode, 30000) : relatedCode
        );
    }

    /**
     * 生成代码质量评估提示词
     */
    public String buildCodeQualityAssessmentPrompt(String code, String filePath, Map<String, Object> metrics) {
        return String.format("""
                # 代码质量综合评估
                
                请对以下代码进行**全面的质量评估**：
                
                **文件**: %s
                
                **代码度量指标**:
                %s
                
                ## 代码
                ```java
                %s
                ```
                
                ---
                
                请从多个维度进行**深度评估**：
                
                ## 一、可读性评估 (20%%)
                1. **命名规范**: 
                   - 变量、方法、类的命名是否清晰、准确？
                   - 是否遵循Java命名约定？
                   - 有没有误导性的命名？
                
                2. **代码组织**:
                   - 代码结构是否清晰？
                   - 方法的长度和复杂度是否适中？
                   - 是否有良好的分段和注释？
                
                3. **可理解性**:
                   - 代码的业务意图是否清晰？
                   - 复杂逻辑是否有充分的解释？
                
                ## 二、可维护性评估 (25%%)
                4. **职责单一性**: 
                   - 每个类/方法是否职责单一？
                   - 有没有承担过多职责的"上帝类"？
                
                5. **耦合度**:
                   - 类之间的耦合程度如何？
                   - 依赖关系是否复杂？
                
                6. **修改的便利性**:
                   - 如果需要修改功能，容易吗？
                   - 修改一处是否会引发连锁反应？
                
                ## 三、设计质量评估 (25%%)
                7. **SOLID原则**:
                   - 单一职责原则 (SRP): ✓ / ✗
                   - 开闭原则 (OCP): ✓ / ✗
                   - 里氏替换原则 (LSP): ✓ / ✗
                   - 接口隔离原则 (ISP): ✓ / ✗
                   - 依赖倒置原则 (DIP): ✓ / ✗
                   
                8. **设计模式应用**:
                   - 是否恰当使用了设计模式？
                   - 有没有过度设计？
                
                9. **扩展性**:
                   - 代码是否便于扩展？
                   - 新增功能是否需要大量修改？
                
                ## 四、健壮性评估 (15%%)
                10. **异常处理**: 
                    - 异常处理是否完善？
                    - 是否有适当的错误恢复机制？
                
                11. **边界条件**: 
                    - 是否考虑了各种边界情况？
                    - 空值检查是否充分？
                
                12. **并发安全**: 
                    - 如果涉及并发，是否线程安全？
                
                ## 五、性能评估 (15%%)
                13. **算法效率**: 时间复杂度和空间复杂度如何？
                14. **资源管理**: 是否有资源泄漏的风险？
                15. **性能瓶颈**: 是否存在明显的性能问题？
                
                ---
                
                **最终评估**:
                - 给出**总体质量评分** (0-100分)
                - 列出**3-5个主要优点**
                - 列出**3-5个主要问题**
                - 提供**具体的改进建议**（可以包含改进后的代码示例）
                
                请开始评估：
                """,
                filePath,
                formatMap(metrics),
                code // 传递完整代码，不截断！
        );
    }

    /**
     * 生成安全性分析提示词
     */
    public String buildSecurityAnalysisPrompt(String code, String filePath, String fileType) {
        return String.format("""
                # 代码安全性分析
                
                作为安全专家，请对以下代码进行**安全审计**：
                
                **文件**: %s
                **类型**: %s
                
                ## 代码
                ```java
                %s
                ```
                
                ---
                
                请进行**全面的安全审查**：
                
                ## 一、输入验证 (25%%)
                1. **用户输入**: 
                   - 是否对所有外部输入进行了验证？
                   - 验证规则是否严格？
                   - 有没有输入注入的风险？（SQL注入、XSS等）
                
                2. **数据校验**:
                   - 是否验证了数据的类型、长度、格式？
                   - 是否有白名单验证？
                
                ## 二、认证与授权 (20%%)
                3. **身份认证**: 
                   - 是否有适当的身份认证机制？
                   - 认证逻辑是否严密？
                
                4. **权限控制**:
                   - 是否检查了用户权限？
                   - 权限控制是否充分？
                   - 有没有越权访问的风险？
                
                ## 三、数据安全 (20%%)
                5. **敏感数据保护**:
                   - 敏感数据（密码、令牌等）是否加密？
                   - 是否有明文存储敏感信息？
                   - 日志中是否泄露敏感信息？
                
                6. **数据传输**:
                   - 数据传输是否安全？
                   - 是否使用了HTTPS/加密通道？
                
                ## 四、常见漏洞检查 (20%%)
                7. **OWASP Top 10检查**:
                   - SQL注入风险
                   - XSS跨站脚本风险
                   - CSRF跨站请求伪造风险
                   - 不安全的反序列化
                   - 使用含有已知漏洞的组件
                   - 不足的日志记录和监控
                   - 其他安全漏洞
                
                ## 五、其他安全考虑 (15%%)
                8. **错误处理**: 
                   - 错误信息是否泄露了敏感信息？
                   - 异常处理是否安全？
                
                9. **资源限制**:
                   - 是否有防止DOS攻击的措施？
                   - 是否限制了资源使用？
                
                10. **依赖安全**:
                    - 使用的第三方库是否安全？
                    - 是否有已知的安全漏洞？
                
                ---
                
                **安全评估报告**:
                - **安全等级**: 高/中/低
                - **发现的安全问题**: 列出所有安全隐患（按严重程度排序）
                - **风险评估**: 每个问题的风险等级和影响
                - **修复建议**: 详细的修复方案
                - **安全最佳实践建议**: 如何提升整体安全性
                
                请开始安全审计：
                """,
                filePath,
                fileType,
                code // 传递完整代码进行安全分析
        );
    }

    /**
     * 生成性能分析提示词
     */
    public String buildPerformanceAnalysisPrompt(String code, String filePath, String context) {
        return String.format("""
                # 代码性能深度分析
                
                作为性能优化专家，请对以下代码进行**性能分析**：
                
                **文件**: %s
                
                **上下文**: %s
                
                ## 代码
                ```java
                %s
                ```
                
                ---
                
                请进行**全方位的性能分析**：
                
                ## 一、算法复杂度分析 (25%%)
                1. **时间复杂度**:
                   - 每个关键方法的时间复杂度是多少？
                   - 有没有可以优化的算法？
                
                2. **空间复杂度**:
                   - 内存使用情况如何？
                   - 有没有不必要的内存开销？
                
                ## 二、性能瓶颈识别 (30%%)
                3. **热点代码**:
                   - 哪些代码可能是性能瓶颈？
                   - 为什么这些代码会成为瓶颈？
                
                4. **数据库操作**:
                   - 是否有N+1查询问题？
                   - 数据库查询是否优化？
                   - 是否需要添加索引？
                
                5. **I/O操作**:
                   - I/O操作是否频繁？
                   - 是否可以批量处理？
                   - 是否使用了缓存？
                
                6. **循环和迭代**:
                   - 循环是否可以优化？
                   - 是否有嵌套循环？
                   - 是否可以并行处理？
                
                ## 三、资源使用分析 (20%%)
                7. **内存管理**:
                   - 是否有内存泄漏风险？
                   - 大对象的创建是否合理？
                   - 是否可以使用对象池？
                
                8. **线程使用**:
                   - 线程的使用是否合理？
                   - 是否有线程安全问题？
                   - 是否可以使用线程池？
                
                9. **连接管理**:
                   - 数据库/网络连接是否正确管理？
                   - 是否使用了连接池？
                
                ## 四、缓存策略 (15%%)
                10. **缓存使用**:
                    - 是否应该使用缓存？
                    - 现有缓存策略是否合理？
                    - 缓存的粒度是否合适？
                
                ## 五、优化建议 (10%%)
                11. **具体优化方案**:
                    - 列出3-5个具体的优化建议
                    - 每个建议说明：优化点、预期收益、实现难度
                    - 可以提供优化后的代码示例
                
                ---
                
                **性能评估**:
                - **性能等级**: 优秀/良好/一般/较差
                - **主要性能问题**: 按影响程度排序
                - **优化优先级**: 哪些优化应该优先进行
                - **预期收益**: 优化后预期的性能提升
                
                请开始性能分析：
                """,
                filePath,
                context.length() > 2000 ? truncate(context, 2000) : context,
                code // 传递完整代码进行性能分析
        );
    }

    /**
     * 生成综合总结提示词
     */
    public String buildComprehensiveSummaryPrompt(Map<String, String> allAnalyses) {
        StringBuilder context = new StringBuilder();
        context.append("基于对项目的全方位深度分析，现在需要生成一份综合性的项目文档。\n\n");
        context.append("## 已完成的分析\n\n");
        
        allAnalyses.forEach((key, value) -> {
            context.append(String.format("### %s\n%s\n\n", key, truncate(value, 800)));
        });

        return String.format("""
                %s
                
                ---
                
                请生成一份**高质量的项目综合文档**，包含以下章节：
                
                # 第一章：项目概述
                - 项目简介（一句话概括 + 详细说明）
                - 核心价值与特色
                - 适用场景
                - 技术栈总览
                
                # 第二章：架构设计
                - 整体架构图（文字描述）
                - 架构风格与设计理念
                - 分层设计说明
                - 核心模块介绍
                - 关键设计决策
                
                # 第三章：技术实现
                - 技术选型分析
                - 核心功能实现
                - 设计模式应用
                - 技术亮点与创新
                
                # 第四章：业务流程
                - 主要业务流程说明
                - 核心业务逻辑
                - 数据流转过程
                
                # 第五章：质量评估
                - 代码质量分析
                - 架构质量评估
                - 安全性评估
                - 性能分析
                
                # 第六章：部署与运维
                - 部署架构
                - 配置说明
                - 运维要点
                
                # 第七章：扩展指南
                - 如何添加新功能
                - 扩展性设计
                - 注意事项
                
                # 第八章：总结与建议
                - 项目总结
                - 优点总结
                - 改进建议
                - 学习价值
                
                ---
                
                **文档要求**:
                - 内容**详实、准确**，不要泛泛而谈
                - 使用**Markdown格式**，结构清晰
                - 包含**代码示例**和**配置示例**
                - 语言**专业、易懂**
                - 总字数：**5000-8000字**
                
                请开始撰写项目文档：
                """,
                context.toString()
        );
    }

    // ========== 辅助方法 ==========

    private String truncate(String text, int maxLength) {
        if (text == null) return "";
        if (text.length() <= maxLength) return text;
        return text.substring(0, maxLength) + "\n...[内容过长，已截断]";
    }

    private String formatMap(Map<String, Object> map) {
        if (map == null || map.isEmpty()) return "无";
        StringBuilder sb = new StringBuilder();
        map.forEach((key, value) -> {
            sb.append("- ").append(key).append(": ").append(value).append("\n");
        });
        return sb.toString();
    }

    private String formatProjectStats(Map<String, Object> stats) {
        if (stats == null || stats.isEmpty()) return "暂无统计数据";
        
        StringBuilder sb = new StringBuilder();
        stats.forEach((key, value) -> {
            sb.append("- **").append(key).append("**: ").append(value).append("\n");
        });
        return sb.toString();
    }
}

